package com.tanhua.dubbo.api;

import com.tanhua.model.mongo.*;
import com.tanhua.model.vo.TestOptionVo;
import org.apache.dubbo.config.annotation.DubboService;
import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;

import java.util.*;

@DubboService
public class TestSoulApiImpl implements TestSoulApi {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 查询所有试卷的方法
     *
     * @return
     */
    @Override
    public List<TestPaper> getPages() {
        return mongoTemplate.findAll(TestPaper.class);
    }

    /**
     * 查询所有的问题  返回的是一个map集合  集合的key是问题的id
     *
     * @return
     */
    @Override
    public Map<String, TestQuestion> getQuestions() {

        //调用方法 进行查询  查询出所有的问题的列表
        List<TestQuestion> questionList = mongoTemplate.findAll(TestQuestion.class);

        //因为返回的值是一个Map类型  所以需要构造一下
        Map<String, TestQuestion> map = new HashMap();

        //map集合的key 就是  问题的id
        for (TestQuestion question : questionList) {
            String id = question.getId().toString();
            map.put(id, question);
        }

        //返回
        return map;
    }

    /**
     * 查看所有选项的id
     *
     * @return
     */
    @Override
    public Map<String, List<TestOptionVo>> getOptions(Set<String> questionIds) {
        //初始化一个集合  用来返回
        Map<String, List<TestOptionVo>> map = new HashMap();
        //循环遍历  根据问题的id查询出问题的对应的选项
        for (String questionId : questionIds) {
            //构造条件
            Query query = Query.query(Criteria.where("questionId").is(questionId));
            //查询对应问题的选项
            List<TestOption> testOptions = mongoTemplate.find(query, TestOption.class);
            //构造vo对象   准备返回  因为返回的只需要选项的id和
            List<TestOptionVo> vos = new ArrayList<>();
            //遍历构造返回的vo对象
            for (TestOption option : testOptions) {
                TestOptionVo vo = TestOptionVo.init(option);
                vos.add(vo);
            }
            map.put(questionId, vos);
        }
        return map;
    }

    /**
     * 查询用户的报告
     *
     * @param userId
     * @return
     */
    @Override
    public List<Report> findAllReportByUserId(Long userId) {
        Criteria criteria = Criteria.where("userId").is(userId);
        Query query = Query.query(criteria);
        return mongoTemplate.find(query, Report.class);
    }

    /**
     * 根据当前试卷的id和用户的id去查询用户是否有已经生成的报告
     *
     * @param paperId
     * @param userId
     * @return
     */
    @Override
    public Report findReportByUserIdAndPaperId(String paperId, Long userId) {
        Query query = Query.query(Criteria.where("userId").is(userId).and("pageId").is(paperId));
        return mongoTemplate.findOne(query, Report.class);
    }

    /**
     * 根据问题的id去查询问题
     *
     * @param questionId
     * @return
     */
    @Override
    public TestQuestion getQuestionById(String questionId) {
        return mongoTemplate.findById(questionId, TestQuestion.class);
    }

    /**
     * 根据问题的id去查询选项
     *
     * @param optionId
     * @return
     */
    @Override
    public TestOption getOptionById(String optionId) {
        return mongoTemplate.findById(optionId, TestOption.class);
    }

    /**
     * 根据用户的id和问卷的编号判断一下用户是否存在相应的report对象
     *
     * @param userId
     * @param pageId
     * @return
     */
    @Override
    public Report findReportByUPId(Long userId, String pageId) {
        Query query = Query.query(Criteria.where("userId").is(userId).and("pageId").is(pageId));
        return mongoTemplate.findOne(query, Report.class);
    }

    /**
     * 删除report的方法
     *
     * @param hasRepot
     */
    @Override
    public void deleteReport(Report hasRepot) {
        Query query = Query.query(Criteria.where("id").is(hasRepot.getId().toString()));
        mongoTemplate.remove(query, Report.class);
    }

    /**
     * 查询用户报告的方法
     * @param report
     * @return
     */
    @Override
    public String saveReport(Report report) {
        //设置保存的时间
        report.setDate(System.currentTimeMillis());
        Report resultReport = mongoTemplate.save(report);
        return resultReport.getId().toString();
    }

    /**
     * 查询用户报告的方法
     * @param userId
     * @param reportId
     * @return
     */
    @Override
    public Report findReportById(Long userId, String reportId) {
        Query query=Query.query(Criteria.where("userId").is(userId).and("id").is(new ObjectId(reportId)));
        return mongoTemplate.findOne(query, Report.class);
    }

    /**
     * 根据成绩的返回用户的性格表的对象
     * @param score
     * @param pageId
     * @return
     */
    @Override
    public Analysis findAnaByScore(int score, String pageId) {
        Query query=Query.query(Criteria.where("paperId").is(pageId)
                .and("start").lt(score));
        query.addCriteria(Criteria.where("end").gte(score));
        Analysis analysis = mongoTemplate.findOne(query, Analysis.class);
        return analysis;
    }

    @Override
    public List<Report> findByAnalysisId(String analysisId) {
        Query query=Query.query(Criteria.where("analysisId").is(analysisId));
        List<Report> reportList = mongoTemplate.find(query, Report.class);
        return reportList;
    }


}
